const path = require('path');
const fs = require('fs');

// 加载题库文件
const loadQuestionBank = (assessmentId = 1) => {
  try {
    // 获取question_bank目录下的所有JSON文件
    const questionBankDir = path.join(__dirname, '../question_bank');
    const files = fs.readdirSync(questionBankDir).filter(file => file.endsWith('.json'));
    
    // 根据assessmentId选择要加载的文件
    const fileIndex = parseInt(assessmentId) - 1;
    
    if (fileIndex >= 0 && fileIndex < files.length) {
      const filePath = path.join(questionBankDir, files[fileIndex]);
      const fileContent = fs.readFileSync(filePath, 'utf8');
      const questions = JSON.parse(fileContent);
      return questions;
    } else {
      // 如果找不到指定ID的文件，尝试根据文件名匹配
      // 例如assessmentId=1对应"中学生心理健康量表.json"
      const targetFile = files.find(file => {
        const fileName = file.toLowerCase();
        return assessmentId === 1 ? fileName.includes('心理健康') : fileName.includes('心理测试题库');
      });
      
      if (targetFile) {
        const filePath = path.join(questionBankDir, targetFile);
        const fileContent = fs.readFileSync(filePath, 'utf8');
        const questions = JSON.parse(fileContent);
        return questions;
      } else {
        // 如果找不到匹配的文件，默认加载第一个文件
        const filePath = path.join(questionBankDir, files[0]);
        const fileContent = fs.readFileSync(filePath, 'utf8');
        const questions = JSON.parse(fileContent);
        return questions;
      }
    }
  } catch (error) {
    console.error('加载题库文件失败:', error);
    throw new Error('题库文件加载失败');
  }
};

// 题库数据（只加载一次，缓存起来）
let questionBank = null;

const questionService = {
  // 初始化题库
  initialize(assessmentId = 1) {
    questionBank = loadQuestionBank(assessmentId);
  },

  // 根据测评ID重置题库
  resetQuestionBank(assessmentId) {
    this.initialize(assessmentId);
  },

  // 获取所有问题
  getAllQuestions() {
    if (!questionBank) {
      this.initialize();
    }
    return questionBank;
  },

  // 根据维度获取问题
  getQuestionsByDimension(dimension) {
    if (!questionBank) {
      this.initialize();
    }
    return questionBank.filter(question => question.dimension === dimension);
  },

  // 获取所有维度
  getAllDimensions() {
    if (!questionBank) {
      this.initialize();
    }
    const dimensions = [...new Set(questionBank.map(question => question.dimension))];
    return dimensions;
  },

  // 根据问题ID获取问题
  getQuestionById(questionId) {
    if (!questionBank) {
      this.initialize();
    }
    return questionBank.find(question => question.question_id === questionId);
  },

  // 验证答案是否有效
  validateAnswers(answers) {
    if (!questionBank) {
      this.initialize();
    }

    // 检查答案格式是否正确
    if (!answers || typeof answers !== 'object') {
      throw new Error('答案格式不正确');
    }

    // 检查是否包含所有问题的答案
    const expectedQuestionIds = questionBank.map(q => q.question_id);
    const providedQuestionIds = Object.keys(answers).map(id => parseInt(id));

    // 验证每个答案是否有效
    for (const questionId in answers) {
      const questionIdInt = parseInt(questionId);
      const answer = answers[questionId];
      
      // 检查问题ID是否存在
      const question = this.getQuestionById(questionIdInt);
      if (!question) {
        throw new Error(`问题ID ${questionId} 不存在`);
      }
      
      // 检查答案是否有效
      const isValidAnswer = question.options.some(option => option.text === answer || option.score === answer);
      if (!isValidAnswer) {
        throw new Error(`问题 ${questionId} 的答案无效`);
      }
    }

    return true;
  },

  // 计算测评结果得分
  calculateScores(answers) {
    if (!questionBank) {
      this.initialize();
    }

    // 验证答案
    this.validateAnswers(answers);

    // 按维度计算得分
    const dimensionScores = {};
    const dimensionCounts = {};

    // 初始化各维度的得分和问题数
    this.getAllDimensions().forEach(dimension => {
      dimensionScores[dimension] = 0;
      dimensionCounts[dimension] = 0;
    });

    // 计算每个问题的得分并累加到对应维度
    for (const questionId in answers) {
      const questionIdInt = parseInt(questionId);
      const answer = answers[questionId];
      const question = this.getQuestionById(questionIdInt);
      
      if (question) {
        // 查找答案对应的分数
        let score = 0;
        if (typeof answer === 'number') {
          // 如果答案直接是分数
          score = answer;
        } else {
          // 如果答案是选项文本，查找对应的分数或代码
          const option = question.options.find(opt => opt.text === answer);
          if (option) {
            if (option.score) {
              score = option.score;
            } else if (option.code) {
              // 对于使用code字段的测评（如人格测试、职业兴趣测评），为不同的code分配不同的分数
              // 这里简单地将不同的code映射为不同的分数值
              const codeToScoreMap = {
                'E': 5, 'I': 1, // 外倾/内倾
                'S': 5, 'N': 1, // 感觉/直觉
                'T': 5, 'F': 1, // 思考/情感
                'J': 5, 'P': 1, // 判断/感知
                'R': 5, 'I': 4, 'A': 3, 'S': 2, 'E': 1, 'C': 0 // 职业兴趣代码
              };
              score = codeToScoreMap[option.code] || 1; // 默认分数为1
            }
          }
        }
        
        dimensionScores[question.dimension] += score;
        dimensionCounts[question.dimension]++;
      }
    }

    // 计算每个维度的平均分
    const result = {};
    for (const dimension in dimensionScores) {
      if (dimensionCounts[dimension] > 0) {
        // 保留一位小数
        result[dimension] = parseFloat((dimensionScores[dimension] / dimensionCounts[dimension]).toFixed(1));
      }
    }

    return result;
  },

  // 生成测评报告
  generateReport(scores) {
    const report = {
      dimensions: [],
      summary: '',
      suggestions: ''
    };

    // 各维度的评估标准（简单示例，实际应用中可能需要更专业的评估标准）
    const evaluationCriteria = {
      '焦虑': {
        1: '无焦虑倾向',
        2: '轻度焦虑倾向',
        3: '中度焦虑倾向',
        4: '重度焦虑倾向',
        5: '严重焦虑倾向'
      },
      '抑郁': {
        1: '无抑郁倾向',
        2: '轻度抑郁倾向',
        3: '中度抑郁倾向',
        4: '重度抑郁倾向',
        5: '严重抑郁倾向'
      },
      '强迫': {
        1: '无强迫倾向',
        2: '轻度强迫倾向',
        3: '中度强迫倾向',
        4: '重度强迫倾向',
        5: '严重强迫倾向'
      },
      // 其他维度的评估标准...
    };

    // 为每个维度生成评估
    Object.entries(scores).forEach(([dimension, score]) => {
      let evaluation = '';
      if (evaluationCriteria[dimension]) {
        // 根据分数确定评估等级（1-5分对应不同等级）
        const level = Math.round(score);
        evaluation = evaluationCriteria[dimension][level] || '需要进一步评估';
      } else {
        evaluation = '需要进一步评估';
      }

      report.dimensions.push({
        name: dimension,
        score: score,
        evaluation: evaluation
      });
    });

    // 生成总结和建议
    report.summary = '根据您的测评结果，您在各心理维度上的表现如下。';
    report.suggestions = '建议保持健康的生活方式，如规律作息、适当运动、保持良好的社交关系。如有需要，请咨询专业心理医生。';

    return report;
  }
};

// 初始化题库
questionService.initialize();

module.exports = questionService;